// Copyright 2021 The Cockroach Authors.
//
// Use of this software is governed by the Business Source License
// included in the file licenses/BSL.txt.
//
// As of the Change Date specified in that file, in accordance with
// the Business Source License, use of this software will be governed
// by the Apache License, Version 2.0, included in the file
// licenses/APL.txt.

package tests

var rubyPGBlocklist = blocklist{
	`Basic type mapping PG::BasicTypeMapBasedOnResult with usage of result oids for bind params encoder selection can do JSON conversions`:                                                                                      "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries Record encoding should do array-as-record encoding`:                                                                                                                          "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries can be initialized with a CoderMapsBundle instead of a connection`:                                                                                                           "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries can be initialized with a custom type registry`:                                                                                                                              "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries can take a Proc and nitify about undefined types`:                                                                                                                            "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries raises UndefinedEncoder for undefined types`:                                                                                                                                 "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do IPAddr param encoding`:                                                                                                                                             "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do array of string encoding on unknown classes`:                                                                                                                       "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do array-as-json encoding`:                                                                                                                                            "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do basic Time encoding`:                                                                                                                                               "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do basic param encoding`:                                                                                                                                              "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do basic param encoding of various float values`:                                                                                                                      "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do bigdecimal param encoding`:                                                                                                                                         "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do default array-as-array param encoding`:                                                                                                                             "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do default array-as-array param encoding with Time objects`:                                                                                                           "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should do hash-as-json encoding`:                                                                                                                                             "unknown",
	`Basic type mapping PG::BasicTypeMapForQueries should take BinaryData for bytea columns`:                                                                                                                                    "unknown",
	`Basic type mapping PG::BasicTypeMapForResults can be initialized with a custom type registry`:                                                                                                                              "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should convert format 0 timestamps per TimestampLocal`:                                                                                          "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should convert format 0 timestamps per TimestampUtc`:                                                                                            "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should convert format 0 timestamps per TimestampUtcToLocal`:                                                                                     "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should convert format 0 timestamps with time zone`:                                                                                              "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should convert format 1 timestamps per TimestampLocal`:                                                                                          "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should convert format 1 timestamps per TimestampUtc`:                                                                                            "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should convert format 1 timestamps per TimestampUtcToLocal`:                                                                                     "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should convert format 1 timestamps with time zone`:                                                                                              "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should do array type conversions`:                                                                                                               "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should do cidr type conversions`:                                                                                                                "unknown",
	`Basic type mapping PG::BasicTypeMapForResults connection wide type mapping should do text datetime without time zone type conversions`:                                                                                     "unknown",
	`GC.compact should compact PG::TypeMapByClass #328`:                                                                                                                                                                         "unknown",
	`PG::Connection #get_result should send remaining data before waiting`:                                                                                                                                                      "unknown",
	`PG::Connection accepts nil as the timeout in #wait_for_notify `:                                                                                                                                                            "unknown",
	`PG::Connection allows a query to be cancelled`:                                                                                                                                                                             "unknown",
	`PG::Connection calls a block for NOTIFY events if one is given`:                                                                                                                                                            "unknown",
	`PG::Connection calls the block supplied to wait_for_notify with the notify payload if it accepts any number of arguments`:                                                                                                  "unknown",
	`PG::Connection calls the block supplied to wait_for_notify with the notify payload if it accepts three arguments`:                                                                                                          "unknown",
	`PG::Connection calls the block supplied to wait_for_notify with the notify payload if it accepts two arguments`:                                                                                                            "unknown",
	`PG::Connection calls the block supplied to wait_for_notify with the notify payload if it doesn't accept arguments`:                                                                                                         "unknown",
	`PG::Connection can receive notices while waiting for NOTIFY without exceeding the timeout`:                                                                                                                                 "unknown",
	`PG::Connection can wait for NOTIFY events`:                                                                                                                                                                                 "unknown",
	`PG::Connection carries the connection in case of connection errors`:                                                                                                                                                        "unknown",
	`PG::Connection connection information related to SSL can retrieve a single ssl connection attribute`:                                                                                                                       "unknown",
	`PG::Connection connection information related to SSL can retrieve connection's ssl state`:                                                                                                                                  "unknown",
	`PG::Connection connects using URI with UnixSocket host`:                                                                                                                                                                    "unknown",
	`PG::Connection deprecated forms of methods should forward exec to exec_params`:                                                                                                                                             "unknown",
	`PG::Connection deprecated forms of methods should forward send_query to send_query_params`:                                                                                                                                 "unknown",
	`PG::Connection doesn't collapse sequential notifications`:                                                                                                                                                                  "unknown",
	`PG::Connection doesn't leave stale server connections after finish`:                                                                                                                                                        "unknown",
	`PG::Connection emits a suitable error_message at connection errors`:                                                                                                                                                        "unknown",
	`PG::Connection in nonblocking mode can send query with params`:                                                                                                                                                             "unknown",
	`PG::Connection in nonblocking mode needs to flush data after send_query`:                                                                                                                                                   "unknown",
	`PG::Connection in nonblocking mode returns immediately from get_copy_data(nonblock=true)`:                                                                                                                                  "unknown",
	`PG::Connection large objects large object can handle big data`:                                                                                                                                                             "unknown",
	`PG::Connection large objects not read past the end of a large object`:                                                                                                                                                      "unknown",
	`PG::Connection multinationalization support Ruby 1.9.x default_internal encoding allows users of the async interface to set the client_encoding to the default_internal`:                                                   "unknown",
	`PG::Connection multinationalization support Ruby 1.9.x default_internal encoding honors the Encoding.default_internal if it's set and the synchronous interface is used`:                                                   "unknown",
	`PG::Connection multinationalization support encodes exception messages with the connection's encoding (#96)`:                                                                                                               "unknown",
	`PG::Connection multinationalization support handles clearing result in or after set_notice_receiver`:                                                                                                                       "unknown",
	`PG::Connection multinationalization support receives properly encoded messages in the notice callbacks`:                                                                                                                    "unknown",
	`PG::Connection multinationalization support receives properly encoded text from wait_for_notify`:                                                                                                                           "unknown",
	`PG::Connection multinationalization support respect and convert character encoding of input strings should convert query string and parameters to #exec_params`:                                                            "unknown",
	`PG::Connection multinationalization support respect and convert character encoding of input strings should convert query string and parameters to #send_query_params`:                                                      "unknown",
	`PG::Connection multinationalization support respect and convert character encoding of input strings should convert strings and parameters to #prepare and #exec_prepared`:                                                  "unknown",
	`PG::Connection multinationalization support respect and convert character encoding of input strings should convert strings and parameters to #send_prepare and #send_query_prepared`:                                       "unknown",
	`PG::Connection multinationalization support returns properly encoded text from notifies`:                                                                                                                                   "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support raises appropriate error if set_client_encoding is called with invalid arguments`:                                                               "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support returns the results in the correct encoding even if the client_encoding has changed since the results were fetched`:                             "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support should return results in the same encoding as the client (EUC-JP)`:                                                                              "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support should return results in the same encoding as the client (iso-8859-1)`:                                                                          "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support the connection should return ASCII-8BIT when it's set to SQL_ASCII`:                                                                             "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support the connection should use the BINARY encoding when it's set to JOHAB`:                                                                           "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support uses the client encoding for escaped identifier`:                                                                                                "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support uses the client encoding for escaped literal`:                                                                                                   "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support uses the client encoding for escaped string`:                                                                                                    "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support uses the client encoding for quote_ident`:                                                                                                       "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support uses the previous string encoding for escaped string`:                                                                                           "unknown",
	`PG::Connection multinationalization support rubyforge #22925: m17n support uses the previous string encoding for quote_ident`:                                                                                              "unknown",
	`PG::Connection returns notifications which are already in the queue before wait_for_notify is called without waiting for the socket to become readable`:                                                                    "unknown",
	`PG::Connection sends nil as the payload if the notification wasn't given one`:                                                                                                                                              "unknown",
	`PG::Connection set_single_row_mode should receive rows before entire query is finished`:                                                                                                                                    "unknown",
	`PG::Connection trace and untrace client-server communication`:                                                                                                                                                              "unknown",
	`PG::Connection type casting can type cast parameters to put_copy_data with explicit encoder`:                                                                                                                               "unknown",
	`PG::Connection type casting shouldn't type map params unless requested`:                                                                                                                                                    "unknown",
	`PG::Connection type casting with default query type map can process #copy_data input queries with row encoder and respects character encoding`:                                                                             "unknown",
	`PG::Connection type casting with default result type map can process #copy_data output with row decoder and respects character encoding`:                                                                                   "unknown",
	`PG::Connection type casting with default result type map should respect a type mapping for result`:                                                                                                                         "unknown",
	`PG::Connection type casting with default result type map should work with arbitrary number of params in conjunction with type casting`:                                                                                     "unknown",
	`PG::Connection with async established connection provides the server generated error message`:                                                                                                                              "unknown",
	`PG::Connection with multiple PostgreSQL servers honors target_session_attrs requirements`:                                                                                                                                  "unknown",
	`PG::Connection#copy_data can handle client errors in #copy_data for input`:                                                                                                                                                 "unknown",
	`PG::Connection#copy_data can handle server errors in #copy_data for input`:                                                                                                                                                 "unknown",
	`PG::Connection#copy_data can process #copy_data input queries`:                                                                                                                                                             "unknown",
	`PG::Connection#copy_data can process #copy_data input queries with lots of data`:                                                                                                                                           "unknown",
	`PG::Connection#copy_data doesn't lose client error when #copy_data can not be finished`:                                                                                                                                    "unknown",
	`PG::Connection#copy_data gracefully handle SQL statements while in #copy_data for input`:                                                                                                                                   "unknown",
	`PG::Connection#discard_results returns false on connection failures`:                                                                                                                                                       "unknown",
	`PG::Connection#inspect should tell about non UTF8 client encoding`:                                                                                                                                                         "unknown",
	`PG::Connection#transaction doesn't worry about an already finished connection`:                                                                                                                                             "unknown",
	`PG::Connection#transaction stops a thread that runs a blocking transaction with exec`:                                                                                                                                      "unknown",
	`PG::Connection#transaction stops a thread that runs a failing transaction with exec`:                                                                                                                                       "unknown",
	`PG::Connection#transaction stops a thread that runs a no query but a transacted ruby sleep`:                                                                                                                                "unknown",
	`PG::Result encapsulates database object names for integrity constraint violations`:                                                                                                                                         "unknown",
	`PG::Result encapsulates errors in a PG::Error object`:                                                                                                                                                                      "unknown",
	`PG::Result raises a proper exception for a nonexistant schema`:                                                                                                                                                             "unknown",
	`PG::TypeMapByOid should allow building new TypeMapByColumn for a given result`:                                                                                                                                             "unknown",
	`PG::TypeMapByOid should allow mixed type conversions in binary format`:                                                                                                                                                     "unknown",
	`PG::TypeMapByOid should allow mixed type conversions in text format`:                                                                                                                                                       "unknown",
	`PG::TypeMapByOid should build a TypeMapByColumn when assigned and the number of rows is high enough`:                                                                                                                       "unknown",
	`running with sync_* methods PG::Connection #get_result should send remaining data before waiting`:                                                                                                                          "unknown",
	`running with sync_* methods PG::Connection accepts nil as the timeout in #wait_for_notify `:                                                                                                                                "unknown",
	`running with sync_* methods PG::Connection allows a query to be cancelled`:                                                                                                                                                 "unknown",
	`running with sync_* methods PG::Connection calls a block for NOTIFY events if one is given`:                                                                                                                                "unknown",
	`running with sync_* methods PG::Connection calls the block supplied to wait_for_notify with the notify payload if it accepts any number of arguments`:                                                                      "unknown",
	`running with sync_* methods PG::Connection calls the block supplied to wait_for_notify with the notify payload if it accepts three arguments`:                                                                              "unknown",
	`running with sync_* methods PG::Connection calls the block supplied to wait_for_notify with the notify payload if it accepts two arguments`:                                                                                "unknown",
	`running with sync_* methods PG::Connection calls the block supplied to wait_for_notify with the notify payload if it doesn't accept arguments`:                                                                             "unknown",
	`running with sync_* methods PG::Connection can receive notices while waiting for NOTIFY without exceeding the timeout`:                                                                                                     "unknown",
	`running with sync_* methods PG::Connection can wait for NOTIFY events`:                                                                                                                                                     "unknown",
	`running with sync_* methods PG::Connection carries the connection in case of connection errors`:                                                                                                                            "unknown",
	`running with sync_* methods PG::Connection connection information related to SSL can retrieve a single ssl connection attribute`:                                                                                           "unknown",
	`running with sync_* methods PG::Connection connection information related to SSL can retrieve connection's ssl state`:                                                                                                      "unknown",
	`running with sync_* methods PG::Connection connects using URI with UnixSocket host`:                                                                                                                                        "unknown",
	`running with sync_* methods PG::Connection deprecated forms of methods should forward exec to exec_params`:                                                                                                                 "unknown",
	`running with sync_* methods PG::Connection deprecated forms of methods should forward send_query to send_query_params`:                                                                                                     "unknown",
	`running with sync_* methods PG::Connection doesn't collapse sequential notifications`:                                                                                                                                      "unknown",
	`running with sync_* methods PG::Connection doesn't leave stale server connections after finish`:                                                                                                                            "unknown",
	`running with sync_* methods PG::Connection emits a suitable error_message at connection errors`:                                                                                                                            "unknown",
	`running with sync_* methods PG::Connection in nonblocking mode can send query with params`:                                                                                                                                 "unknown",
	`running with sync_* methods PG::Connection in nonblocking mode needs to flush data after send_query`:                                                                                                                       "unknown",
	`running with sync_* methods PG::Connection in nonblocking mode returns immediately from get_copy_data(nonblock=true)`:                                                                                                      "unknown",
	`running with sync_* methods PG::Connection large objects large object can handle big data`:                                                                                                                                 "unknown",
	`running with sync_* methods PG::Connection large objects not read past the end of a large object`:                                                                                                                          "unknown",
	`running with sync_* methods PG::Connection multinationalization support Ruby 1.9.x default_internal encoding allows users of the async interface to set the client_encoding to the default_internal`:                       "unknown",
	`running with sync_* methods PG::Connection multinationalization support Ruby 1.9.x default_internal encoding honors the Encoding.default_internal if it's set and the synchronous interface is used`:                       "unknown",
	`running with sync_* methods PG::Connection multinationalization support encodes exception messages with the connection's encoding (#96)`:                                                                                   "unknown",
	`running with sync_* methods PG::Connection multinationalization support handles clearing result in or after set_notice_receiver`:                                                                                           "unknown",
	`running with sync_* methods PG::Connection multinationalization support receives properly encoded messages in the notice callbacks`:                                                                                        "unknown",
	`running with sync_* methods PG::Connection multinationalization support receives properly encoded text from wait_for_notify`:                                                                                               "unknown",
	`running with sync_* methods PG::Connection multinationalization support respect and convert character encoding of input strings should convert query string and parameters to #exec_params`:                                "unknown",
	`running with sync_* methods PG::Connection multinationalization support respect and convert character encoding of input strings should convert query string and parameters to #send_query_params`:                          "unknown",
	`running with sync_* methods PG::Connection multinationalization support respect and convert character encoding of input strings should convert strings and parameters to #prepare and #exec_prepared`:                      "unknown",
	`running with sync_* methods PG::Connection multinationalization support respect and convert character encoding of input strings should convert strings and parameters to #send_prepare and #send_query_prepared`:           "unknown",
	`running with sync_* methods PG::Connection multinationalization support returns properly encoded text from notifies`:                                                                                                       "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support raises appropriate error if set_client_encoding is called with invalid arguments`:                                   "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support returns the results in the correct encoding even if the client_encoding has changed since the results were fetched`: "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support should return results in the same encoding as the client (EUC-JP)`:                                                  "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support should return results in the same encoding as the client (iso-8859-1)`:                                              "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support the connection should return ASCII-8BIT when it's set to SQL_ASCII`:                                                 "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support the connection should use the BINARY encoding when it's set to JOHAB`:                                               "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support uses the client encoding for escaped identifier`:                                                                    "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support uses the client encoding for escaped literal`:                                                                       "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support uses the client encoding for escaped string`:                                                                        "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support uses the client encoding for quote_ident`:                                                                           "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support uses the previous string encoding for escaped string`:                                                               "unknown",
	`running with sync_* methods PG::Connection multinationalization support rubyforge #22925: m17n support uses the previous string encoding for quote_ident`:                                                                  "unknown",
	`running with sync_* methods PG::Connection returns notifications which are already in the queue before wait_for_notify is called without waiting for the socket to become readable`:                                        "unknown",
	`running with sync_* methods PG::Connection sends nil as the payload if the notification wasn't given one`:                                                                                                                  "unknown",
	`running with sync_* methods PG::Connection set_single_row_mode should receive rows before entire query is finished`:                                                                                                        "unknown",
	`running with sync_* methods PG::Connection trace and untrace client-server communication`:                                                                                                                                  "unknown",
	`running with sync_* methods PG::Connection type casting can type cast parameters to put_copy_data with explicit encoder`:                                                                                                   "unknown",
	`running with sync_* methods PG::Connection type casting shouldn't type map params unless requested`:                                                                                                                        "unknown",
	`running with sync_* methods PG::Connection type casting with default query type map can process #copy_data input queries with row encoder and respects character encoding`:                                                 "unknown",
	`running with sync_* methods PG::Connection type casting with default result type map can process #copy_data output with row decoder and respects character encoding`:                                                       "unknown",
	`running with sync_* methods PG::Connection type casting with default result type map should respect a type mapping for result`:                                                                                             "unknown",
	`running with sync_* methods PG::Connection type casting with default result type map should work with arbitrary number of params in conjunction with type casting`:                                                         "unknown",
	`running with sync_* methods PG::Connection with async established connection provides the server generated error message`:                                                                                                  "unknown",
	`running with sync_* methods PG::Connection with multiple PostgreSQL servers honors target_session_attrs requirements`:                                                                                                      "unknown",
	`running with sync_* methods PG::Connection#copy_data can handle client errors in #copy_data for input`:                                                                                                                     "unknown",
	`running with sync_* methods PG::Connection#copy_data can handle server errors in #copy_data for input`:                                                                                                                     "unknown",
	`running with sync_* methods PG::Connection#copy_data can process #copy_data input queries`:                                                                                                                                 "unknown",
	`running with sync_* methods PG::Connection#copy_data can process #copy_data input queries with lots of data`:                                                                                                               "unknown",
	`running with sync_* methods PG::Connection#copy_data doesn't lose client error when #copy_data can not be finished`:                                                                                                        "unknown",
	`running with sync_* methods PG::Connection#copy_data gracefully handle SQL statements while in #copy_data for input`:                                                                                                       "unknown",
	`running with sync_* methods PG::Connection#discard_results returns false on connection failures`:                                                                                                                           "unknown",
	`running with sync_* methods PG::Connection#inspect should tell about non UTF8 client encoding`:                                                                                                                             "unknown",
	`with a Fiber scheduler can cancel a query`:                                                                                                                                                                                 "unknown",
	`with a Fiber scheduler can receive COPY data`:                                                                                                                                                                              "unknown",
	`with a Fiber scheduler can retrieve several results`:                                                                                                                                                                       "unknown",
	`with a Fiber scheduler can retrieve the last one of several results`:                                                                                                                                                       "unknown",
	`with a Fiber scheduler can send lots of data per put_copy_data`:                                                                                                                                                            "unknown",
	`with a Fiber scheduler can set_client_encoding`:                                                                                                                                                                            "unknown",
	`with a Fiber scheduler connects to a server with setting default encoding`:                                                                                                                                                 "unknown",
	`with a Fiber scheduler should convert strings and parameters to #prepare and #exec_prepared`:                                                                                                                               "unknown",
	`with a Fiber scheduler waits when sending query data`:                                                                                                                                                                      "unknown",
}

var rubyPGIgnorelist = blocklist{
	`PG::Connection consume_input should raise ConnectionBad for a closed connection`:                                                                                              "flaky",
	`PG::Connection handles server close while asynchronous connect`:                                                                                                               "flaky",
	`PG::Connection OS thread support Connection.new shouldn't block a second thread`:                                                                                              "flaky",
	`PG::Connection multinationalization support respect and convert character encoding of input strings should convert error string to #put_copy_end`:                             "unknown",
	`PG::Connection in nonblocking mode rejects to send lots of COPY data`:                                                                                                         "flaky",
	`PG::Connection times out after connect_timeout seconds`:                                                                                                                       "flaky",
	`running with sync_* methods PG::Connection in nonblocking mode rejects to send lots of COPY data`:                                                                             "flaky",
	`running with sync_* methods PG::Connection consume_input should raise ConnectionBad for a closed connection`:                                                                  "flaky",
	`running with sync_* methods PG::Connection OS thread support Connection.new shouldn't block a second thread`:                                                                  "flaky",
	`running with sync_* methods PG::Connection handles server close while asynchronous connect`:                                                                                   "flaky",
	`running with sync_* methods PG::Connection multinationalization support respect and convert character encoding of input strings should convert error string to #put_copy_end`: "flaky",
}
